EduGit – Plug-in do Moodle simulando Github

Especificação e Protótipo

Grupo nº Infinito

Integrantes Daniel Ferreira Alves - dandastico.bsb@gmail.com

Prof. Orientador MSc. Edilberto M. Silva - prof.edilberto.silva@gmail.com

11/2025

1. INTRODUÇÃO

O presente documento constitui o Plano de Projeto para o desenvolvimento do EduGit, um plug-in educacional para a plataforma Moodle. O objetivo primordial deste projeto é aprimorar a gestão e o fluxo de trabalho de atividades práticas de programação no ambiente acadêmico, especificamente para alunos e professores da Faculdade SENAC-DF.

O EduGit propõe-se a ser um sistema de controle de versão simplificado, integrado ao Moodle, que visa organizar e gerenciar os códigos-fonte desenvolvidos por alunos em suas atividades. Sua funcionalidade central reside na capacidade de simular um repositório na nuvem, similar ao GitHub, permitindo que os alunos submetam suas soluções via comandos simplificados de terminal.

Um diferencial estratégico do EduGit é a incorporação de uma plataforma de testes automatizados. Esta funcionalidade permitirá aos professores configurar testes unitários que serão executados automaticamente contra o código submetido pelos alunos. Este mecanismo tem o propósito de acelerar significativamente o processo de correção das atividades e fornecer feedback imediato e objetivo aos estudantes, alinhando-se a modelos de ensino de programação de alta performance.

Este Plano de Projeto detalha o escopo, os objetivos de alto nível, os requisitos funcionais, a estrutura de trabalho e o cronograma proposto para a entrega da primeira versão funcional do EduGit até o final do semestre letivo vigente (27/11/2025). O sucesso do projeto será medido pela sua capacidade de fornecer uma ferramenta robusta e eficiente que otimize o processo de ensino-aprendizagem de programação na instituição

2. DESCRIÇÃO DO PROJETO

2.1. Título do Projeto

EduGit

2.2. Objetivos de Alto Nível

3. ESCOPO DO PROJETO

Funcionalidades Principais:

Limitações:

3.1. Escopo do Produto (Requisitos Funcionais)

3.2. Requisitos do Projeto

4. DIAGRAMA DE CASO DE USO

5. MODELO ENTIDADE E RELACIONAMENTO (MER)

erDiagram
  USUARIO {
      int id PK
      varchar nome
      varchar email UK
      varchar senha_hash
      varchar tipo_usuario
      varchar codigo_validacao
      datetime data_cadastro
  }
    
  CURSO_GRADUACAO {
      int id PK
      varchar nome_curso
  }
    
  TURMA {
      int id PK
      int curso_graduacao_id FK
      varchar nome_turma
      varchar semestre
  }
  
  TURMA_USUARIO {
      int usuario_id PK,FK
      int turma_id PK,FK
      varchar papel
  }
    
  ATIVIDADE {
      int id PK
      int turma_id FK
      varchar titulo
      text descricao
      datetime prazo_entrega
      varchar template_path
      int pontuacao_maxima
  }
    
  TESTE_UNITARIO {
      int id PK
      int atividade_id FK
      varchar nome_teste
      text codigo_teste
      int peso_pontuacao
  }
    
  SUBMISSAO {
      int id PK
      int usuario_id FK
      int atividade_id FK
      datetime data_submissao
      varchar arquivo_path
      float pontuacao_final
  }
    
  RESULTADO_TESTE {
      int id PK
      int submissao_id FK
      int teste_unitario_id FK
      boolean passou
      text log_erro
      float pontuacao_obtida
  }

  USUARIO ||--o{ TURMA_USUARIO : "pertence"
  TURMA ||--o{ TURMA_USUARIO : "contém"
  CURSO_GRADUACAO ||--o{ TURMA : "oferece"
  TURMA ||--o{ ATIVIDADE : "possui"
  ATIVIDADE ||--o{ SUBMISSAO : "recebe"
  USUARIO ||--o{ SUBMISSAO : "realiza"
  ATIVIDADE ||--o{ TESTE_UNITARIO : "configura"
  SUBMISSAO ||--o{ RESULTADO_TESTE : "gera"
  TESTE_UNITARIO ||--o{ RESULTADO_TESTE : "avalia"

6. ESPECIFICAÇÃO DOS REQUISITOS

[RF01] Manter cadastro de Usuário Registrar novo usuário com gestão própria.

Este requisito descreve todos os passos para realização do cadastro de um novo usuário no sistema em que o usuário insere nome, email e senha (todos salvos no MySQL, senha criptografada).

Verificação do e-mail para certificar de que o usuário é o verdadeiro proprietário da conta. O processo inclui o envio de um código de verificação de 6 dígitos numéricos aleatórios para o email enviado, validação do código e a possibilidade de reenviar o código de verificação.

Ator: Aluno, Professor

Prioridade:

RF01.1 Consultar Usuário

Consultar Usuário Permite que o usuário visualize seus dados cadastrais.

  1. O usuário acessa a seção "Meu Perfil" nna barra de navegação da plataforma EduGit.
  2. O sistema exibe todas as informações do usuário selecionado, incluindo: nome completo, email, matrícula, tipo de usuário (aluno/professor), data de criação da conta, e status (ativo/inativo).
  3. O usuário pode optar por editar ou excluir o perfil (se tiver permissão).

Resultado Esperado: O usuário consegue visualizar as informações do seu perfil de forma clara e organizada.

RF01.2 Cadastrar Usuário

Permite a criação de um novo registro de usuário no sistema, incluindo a coleta de e-mail e senha.

  1. O usuário acessa a página inicial do EduGit e clica no botão "Criar Conta".
  2. O sistema exibe um formulário de cadastro com os seguintes campos obrigatórios:
  1. O usuário preenche todos os campos do formulário.
  2. O sistema valida os dados em tempo real (veja RF01.3 para detalhes de validação).
  3. Se todos os dados forem válidos, o usuário clica no botão "Criar Conta".
  4. O sistema cria um registro do usuário no banco de dados com status "Pendente de Validação de Email".
  5. O sistema envia um email de confirmação para o endereço fornecido, contendo um link de validação com validade de 24 horas.
  6. O usuário recebe uma mensagem na tela informando que um email de confirmação foi enviado.

Resultado Esperado: Uma nova conta de usuário é criada e um email de confirmação é enviado para o endereço fornecido.

Tela 1

RF01.3 Validar Email

Processo de segurança que envolve a de um link, enviado para o e-mail cadastrado pelo usuário, para confirmar o e-mail do usuário.

  1. Durante o cadastro (RF01.2), o usuário insere um endereço de email.

  2. O sistema valida o formato do email em tempo real, verificando se:

  1. Se o email for inválido ou já registrado, o sistema exibe uma mensagem de erro clara (ex: "Email inválido" ou "Este email já está registrado").
  2. Se o email for válido, o usuário continua o processo de cadastro.
  3. Após a criação da conta, o sistema gera um token único de validação com validade de 24 horas.
  4. O sistema envia um email para o endereço fornecido contendo: -Um link de confirmação (ex: https://edugit.senac-df.edu.br/validar-email?token=abc123xyz )
  1. O usuário clica no link de confirmação no email.
  2. O sistema valida o token e marca o email como "Confirmado" no banco de dados.
  3. O usuário recebe uma mensagem de sucesso e pode fazer login normalmente.

Resultado Esperado: O email do usuário é validado e confirmado, permitindo o acesso pleno à plataforma.

Tela 1

RF01.4 Editar Usuário

Permite a modificação dos dados cadastrais de um usuário existente, como email e senha.

  1. O usuário acessa a seção "Meu Perfil" no menu da plataforma.
  2. O sistema exibe um formulário pré-preenchido com as informações atuais do usuário.
  3. O usuário identifica qual campo deseja modificar (ex: nome, email, senha).
  4. O usuário altera o(s) campo(s) desejado(s).
  5. Se o usuário alterar a senha, o sistema solicita a senha atual para confirmação de identidade.
  6. O usuário clica no botão "Salvar Alterações".
  7. O sistema valida os novos dados (aplicando as mesmas regras de validação de RF01.3 para email, se aplicável).
  8. Se houver erros de validação, o sistema exibe mensagens de erro específicas.
  9. Se os dados forem válidos, o sistema atualiza o registro do usuário no banco de dados.
  10. O usuário recebe uma mensagem de confirmação: "Perfil atualizado com sucesso".

Resultado Esperado: As informações do usuário são atualizadas no sistema e refletidas imediatamente em seu perfil.

Tela 1

[RF02] Gerenciar login do usuário

Permitir que usuários autenticados acessem as funcionalidades do sistema.

Este requisito abrange o processo de autenticação do usuário no sistema, garantindo que apenas usuários cadastrados e validados possam acessar as áreas restritas. Inclui a validação das credenciais (e-mail/senha) e o mecanismo de recuperação de senha.

Ator: Aluno, Professor

Prioridade:

RF02.1 Validar Credencial

O sistema deve verificar se o e-mail e a senha fornecidos pelo usuário correspondem a um registro válido no banco de dados. A senha deve ser comparada após a criptografia.

  1. O usuário acessa a página de login do EduGit.
  2. O sistema exibe um formulário com dois campos: "Email" e "Senha".
  3. O usuário insere seu email institucional (ex: joao.silva@senac-df.edu.br).
  4. O usuário insere sua senha.
  5. O usuário clica no botão "Entrar".
  6. O sistema valida o email:
  1. Se o email for inválido ou não encontrado, o sistema exibe a mensagem: "Email ou senha incorretos" (sem especificar qual é inválido, por segurança).
  2. Se o email for válido, o sistema valida a senha:
  1. Se a senha for incorreta, o sistema exibe a mensagem: "Email ou senha incorretos".
  2. Se a senha for correta, o sistema:

Resultado Esperado: O usuário é autenticado e pode acessar a plataforma EduGit.

Tela 1

RF02.2 Redefinir Senha (esquecer a senha)

Permite que o usuário inicie um processo de recuperação de senha, geralmente envolvendo o envio de um link ou código de segurança para o e-mail cadastrado, para que possa definir uma nova senha.

  1. O usuário acessa a página de login e clica no link "Esqueci minha senha".
  2. O sistema exibe um formulário solicitando o email do usuário.
  3. O usuário insere seu email institucional.
  4. O usuário clica em "Enviar Link de Redefinição".
  5. O sistema verifica se o email existe no banco de dados:
  1. Se o email existir, o sistema:
  1. O usuário recebe o email e clica no link de redefinição.
  2. O sistema valida o token:
  1. Se o token for inválido ou expirado, o sistema exibe a mensagem: "Link inválido ou expirado. Solicite um novo link de redefinição".
  2. Se o token for válido, o sistema exibe um formulário para o usuário inserir uma nova senha.
  3. O usuário insere uma nova senha (seguindo os requisitos de segurança: mínimo 8 caracteres, incluindo letras maiúsculas, minúsculas, números e caracteres especiais).
  4. O usuário clica em "Redefinir Senha".
  5. O sistema valida a nova senha e a armazena no banco de dados (criptografada com hash).
  6. O sistema exibe a mensagem: "Senha redefinida com sucesso. Você pode fazer login com sua nova senha".
  7. O usuário é redirecionado para a página de login.
Tela 1

[RF03] Gerenciar atividades

Permitir que o Professor crie, configure e gerencie as atividades acadêmicas que serão submetidas pelos alunos.

Este requisito é fundamental para o lado do Professor, permitindo a criação de um ambiente de submissão de código. O professor deve ser capaz de definir o escopo da atividade, o prazo, associar templates iniciais e configurar os testes unitários que serão usados na correção automática.

Ator: Professor

Prioridade:

Tela com lista das atividades da turma Tela de criação de atividade Tela da visão do professor da atividade

RF03.1 Criar Atividade

Permite ao Professor definir o título, descrição e parâmetros básicos de uma nova atividade.

  1. O professor acessa o menu "Atividades" e clica em "Criar Nova Atividade".
  2. O sistema exibe um formulário de criação com os seguintes campos:
  1. O professor preenche todos os campos obrigatórios.
  2. O professor clica em "Criar Atividade".
  3. O sistema valida os dados:
  1. Se houver erros de validação, o sistema exibe mensagens de erro específicas.
  2. Se os dados forem válidos, o sistema:

Resultado Esperado: Uma nova atividade é criada no sistema com status "Rascunho" e pronta para ser configurada.

RF03.2 Editar Atividade

Permite ao Professor modificar os detalhes de uma atividade que ainda não foi publicada ou que precisa de ajustes.

  1. O professor acessa o menu "Atividades" e seleciona uma atividade existente.
  2. O sistema exibe a página de detalhes da atividade com um botão "Editar".
  3. O professor clica em "Editar".
  4. O sistema exibe um formulário pré-preenchido com os dados atuais da atividade.
  5. O professor altera os campos desejados (título, descrição, prazo, pontuação, etc.).
  6. O professor clica em "Salvar Alterações".
  7. O sistema valida os dados (aplicando as mesmas regras de validação de RF03.1).
  8. Se houver erros, o sistema exibe mensagens de erro.
  9. Se os dados forem válidos, o sistema:

Resultado Esperado: Os detalhes da atividade são atualizados no sistema.

RF03.3 Excluir Atividade

Permite a remoção de uma atividade do sistema, desde que não haja submissões associadas ou que a exclusão seja permitida pelas regras de negócio.

  1. O professor acessa o menu "Atividades" e seleciona uma atividade.
  2. O sistema exibe a página de detalhes da atividade com um botão "Excluir".
  3. O professor clica em "Excluir".
  4. O sistema exibe um diálogo de confirmação: "Tem certeza que deseja excluir esta atividade? Esta ação é irreversível".
  5. Se a atividade já possui submissões de alunos, o sistema exibe um aviso adicional: "Esta atividade possui X submissões. Ao excluir, todos os dados serão removidos".
  6. O professor clica em "Confirmar Exclusão".
  7. O sistema:
  1. O sistema exibe a mensagem: "Atividade excluída com sucesso".
  2. O professor é redirecionado para a lista de atividades.

Resultado Esperado: A atividade é removida do sistema de forma irreversível.

RF03.4 Publicar/Ocultar Atividade

Permite ao Professor controlar a visibilidade da atividade para os alunos, tornando-a disponível para submissão ou ocultando-a temporariamente.

Descrição: Este requisito permite que um professor controle a visibilidade de uma atividade, tornando-a disponível ou indisponível para os alunos.

Ator Principal: Professor

Prioridade: Essencial

Passo-a-Passo:

  1. O professor acessa o menu "Atividades" e seleciona uma atividade.

  2. O sistema exibe a página de detalhes da atividade com um botão "Publicar" (se o status for "Rascunho") ou "Ocultar" (se o status for "Publicada").

  3. Se o professor clicar em "Publicar":

  1. Se todas as configurações obrigatórias estiverem presentes, o professor clica em "Confirmar Publicação".
  2. O sistema:
  1. O sistema exibe a mensagem: "Atividade publicada com sucesso. Os alunos podem começar a trabalhar nela".
  2. Se o professor clicar em "Ocultar":

Resultado Esperado: O status da atividade é alterado, controlando sua visibilidade para os alunos.

RF03.5 Definir Prazo de Entrega

Permite ao Professor estabelecer a data e hora limite para a submissão dos códigos pelos alunos.

  1. Durante a criação (RF03.1) ou edição (RF03.2) de uma atividade, o professor preenche o campo "Prazo de Entrega".

  2. O sistema exibe um seletor de data e hora, permitindo que o professor escolha:

  1. O professor seleciona a data e hora desejadas.

  2. O sistema valida se a data/hora é futura (não pode ser uma data passada).

  3. Se a data for inválida, o sistema exibe a mensagem: "O prazo deve ser uma data futura".

  4. Se a data for válida, o sistema armazena o prazo no banco de dados.

  5. Quando o prazo se aproxima, o sistema pode enviar notificações automáticas aos alunos (funcionalidade opcional).

  6. Após o prazo expirar, o sistema:

Resultado Esperado: O prazo de entrega é definido e o sistema controla as submissões com base nele.

RF03.6 Configurar Template Inicial

Permite ao Professor anexar ou configurar um arquivo de código inicial (template) que os alunos poderão baixar via terminal para começar a atividade.

  1. Durante a criação ou edição de uma atividade, o professor acessa a seção "Template Inicial".

  2. O sistema exibe um editor de código ou um campo de upload de arquivo.

  3. O professor pode:

  1. O professor insere o código do template (ex: uma função com assinatura definida, mas corpo vazio).

  2. O professor clica em "Salvar Template".

  3. O sistema valida o código:

  1. Se houver erros de validação, o sistema exibe mensagens de erro.

  2. Se o código for válido, o sistema:

  1. Quando um aluno inicia a atividade (RF04.1), o sistema fornece automaticamente uma cópia do template para que ele comece a trabalhar.

Resultado Esperado: Um template inicial é configurado e será fornecido aos alunos quando iniciarem a atividade.

RF03.7 Associar Testes Unitários à Atividade

Permite ao Professor vincular um conjunto de testes unitários (scripts de teste) que serão executados automaticamente contra o código submetido pelo aluno.

  1. Durante a criação ou edição de uma atividade, o professor acessa a seção "Configurar Testes".

  2. O sistema exibe uma interface para adicionar testes unitários.

  3. O professor clica em "Adicionar Novo Teste".

  4. O sistema exibe um formulário com os seguintes campos:

  1. O professor preenche todos os campos.

  2. O professor clica em "Salvar Teste".

  3. O sistema valida o código do teste:

  1. Se houver erros, o sistema exibe mensagens de erro.

  2. Se o código for válido, o sistema armazena o teste no banco de dados e associa à atividade.

  3. O professor pode adicionar múltiplos testes para a mesma atividade.

  4. O sistema verifica se a soma dos pesos de todos os testes é 100%.

  5. Quando um aluno submeter código (RF04.1), os testes configurados serão executados automaticamente (RF05.2).

Resultado Esperado: Testes unitários são configurados e serão executados automaticamente nas submissões dos alunos.

[RF04] Gerenciar Submissões de Código

Permitir que o Aluno envie seu código para correção e que o Professor visualize e gerencie essas submissões.

Este requisito cobre o fluxo de trabalho principal do aluno, que é a submissão do código via terminal. Inclui a validação do formato do arquivo e a capacidade do Professor de listar e baixar os códigos submetidos.

Ator: Aluno, Professor

Prioridade:

RF04.1 Enviar Código via Terminal

Permite ao Aluno executar um comando simplificado (e.g., edugit enviar) no terminal para fazer o upload do seu arquivo de código para o repositório do EduGit.

>>> edugit enviar atividade-maneira

Comando CLI inserido no terminal para enviar atividade

  1. O aluno acessa a atividade no EduGit, copia o comando CLI para baixar a atividade e a executa em seu terminal.

  2. O sistema fornece ao aluno:

  1. O aluno trabalha localmente em seu computador, desenvolvendo a solução.

  2. Quando o aluno termina, ele abre o terminal em seu computador.

  3. O aluno navega até o diretório contendo seu código.

  4. aluno executa o comando de submissão fornecido pelo EduGit:

  5. O cliente EduGit (instalado no computador do aluno) valida o arquivo (veja RF04.2).

  6. Se o arquivo for válido, o cliente envia o código para o servidor EduGit via HTTPS.

  7. O servidor recebe o código e:

  1. O servidor inicia automaticamente a execução dos testes (RF05.2).

  2. O cliente exibe uma mensagem de sucesso: "Código enviado com sucesso! Os testes estão sendo executados...".

  3. O aluno pode verificar o status da submissão acessando a atividade no EduGit.

Resultado Esperado: O código do aluno é enviado com sucesso e os testes são iniciados automaticamente.

RF04.2 Validar Formato do Código

O sistema deve verificar se o arquivo submetido está no formato esperado (inicialmente, apenas arquivos Python .py) e se atende a quaisquer outras regras de formato.

>>> Vertificando estrutura do código...
>>> Funções exigidas pela atividade encontradas...
>>> Envio concluído

Resposta do sistema visto pelo terminal do código validado de acordo com template do professor

>>> Verificando estrutura do código...
>>> Funcções exigidas não encontradas.
>>> Envio cancelado!

Resposta do sistema visto pelo terminal quando o código não foi validado de acordo com o template do professor

  1. Quando um aluno tenta enviar código via terminal (RF04.1), o cliente EduGit valida o arquivo localmente.

  2. O sistema verifica:

  1. Se alguma validação falhar, o sistema exibe uma mensagem de erro específica:

  1. Se todas as validações passarem, o arquivo é aceito e enviado ao servidor.

  2. O servidor também realiza validações adicionais:

  1. Se o servidor detectar problemas, a submissão é rejeitada e o aluno recebe uma mensagem de erro.

Resultado Esperado: Apenas arquivos válidos são aceitos para submissão.

RF04.3 Listar Submissões por Aluno

Permite ao Professor visualizar um histórico de todas as submissões feitas por um aluno específico para uma determinada atividade.

  1. O aluno acessa uma atividade no EduGit.

  2. O aluno clica em "Meu Histórico de Submissões".

  3. O sistema exibe uma tabela com todas as submissões do aluno para essa atividade, incluindo:

  1. O aluno pode clicar em uma submissão específica para ver:

  1. O aluno pode fazer quantas submissões desejar até o prazo (RF03.5).

  2. O sistema mantém um histórico completo de todas as submissões.

Resultado Esperado: O aluno pode visualizar todas as suas submissões e seus resultados.

Tela da visão do professor da atividade

RF04.4 Download do Código Submetido

Permite ao Professor baixar o arquivo de código submetido por um aluno para análise manual, se necessário.

Tela da visão do professor da atividade 
>>> edugit baixar atividade-maneira <nome do aluno>

Comando CLI para baixar código de um aluno específico, de uma atividade específica

  1. O aluno acessa o histórico de submissões (RF04.3) ou o professor acessa a lista de submissões de uma atividade.

  2. O usuário seleciona uma submissão específica.

  3. O sistema exibe os detalhes da submissão com um botão "Baixar Código" ou executa comando no terminal.

  4. O usuário clica em "Baixar Código".

  5. O sistema:

  1. O arquivo é salvo com um nome descritivo, ex: atividade_10_joao_silva_15_11_2025.py.

  2. O sistema registra o download no histórico de atividades (para auditoria).

Resultado Esperado: O arquivo de código é baixado com sucesso para o computador do usuário.

[RF05] Executar Testes Automatizados

Realizar a correção automática do código submetido pelo Aluno com base nos testes unitários configurados pelo Professor.

Este requisito é o cerne da proposta de valor do EduGit, que é acelerar a correção. Ele detalha o processo de configuração, execução e geração de feedback dos testes unitários.

Ator: Professor (Configuração), Sistema (Execução), Aluno (Visualização do Feedback)

Prioridade:

RF05.1 Configurar Testes Unitários

Permite ao Professor fazer o upload ou definir o código dos testes unitários que serão usados para avaliar as submissões.

Tela da visão do professor da atividade

A inserção do código teste é realizado no mesmo local que a criação da ativdade, ou a edição dela

  1. O professor acessa uma atividade e clica em "Configurar Testes".

  2. O sistema exibe uma interface para gerenciar testes (detalhes em RF03.7).

  3. O professor pode:

  1. O professor clica em "Salvar Configuração de Testes".

  2. O sistema valida a configuração:

  1. Se houver erros, o sistema exibe mensagens de erro.

  2. Se a configuração for válida, o sistema armazena os testes e ativa a execução automática.

Resultado Esperado: Os testes são configurados e prontos para serem executados nas submissões.

RF05.2 Executar Testes no Servidor

O sistema deve ser capaz de rodar o código submetido pelo aluno em um ambiente seguro (sandbox) contra os testes unitários associados à atividade.

O teste pode ser realizado das seguintes maneiras:

  1. Teste que não é armazenado em memória: comando é escrito no terminal na IDE compatível, o código é testado e o resultado é visualizado no terminal, podendo ver mais detalhes ao clicar no link. Esse teste não é armazenado a longo prazo na memória, o link da página é temporário.
>>> edugit testar atividade-maneira
Enviando código...
Testando código...
Recebendo resultados...
--------------------------------------
:) Solução de acordo com o template do professor
:) Solução retorna uma string
:) Solução retorna "Daniel"
:) Solução retorna "Carol"
:( Esperava retorno com valor "Edilberto", não "Silva"
Performance: 4/5
-> Mais informações: https://edugit.com.br/testes/atividade-maneira123846513518
  1. Teste armazenado em memória: se o professor não tiver especificado os testes como privado até a data de correção do exercício, o aluno também recebe os resultados dos testes pelo terminal. Dessa vez, os códigos ficam armazenados em memória, podendo visualizar sua Performance durante todo o semestre.
>>> edugit enviar atividade-maneira
Enviando código...
Analisando código...
Código armazenado com sucesso!
Recebendo resultados...
--------------------------------------
:) Solução de acordo com o template do professor
:) Solução retorna uma string
:) Solução retorna "Daniel"
:) Solução retorna "Carol"
:( Esperava retorno com valor "Edilberto", não "Silva"
Performance: 4/5
-> Mais informações: https://edugit.com.br/testes/atividade-maneira123846513518
  1. Teste efetuado em uma data especificada pelo professor, é armazenado em memória: caso o professor tenha especificado os testes unitários como privados, eles só serão efetuados e a Performance publicada após uma data especificada pelo professor, de maneira automática. Dessa maneira, a Performance da sua Solução só pode ser visualizada na página do Moodle, ela não é enviada para o terminal do aluno.
>>> edugit enviar atividade-maneira
Enviando código...
Código armazenado com sucesso!
A solução será corrigida em: 27/11/2025

Mensagens no terminal após enviar a solução para uma atividade com os testes privados

  1. Quando um aluno submete código (RF04.1), o servidor EduGit recebe o arquivo.

  2. O servidor cria um ambiente isolado (sandbox/container) para executar os testes.

  3. O servidor copia o arquivo de código do aluno para o ambiente isolado.

  4. O servidor copia o arquivo de template (se houver) para o ambiente isolado.

  5. O servidor copia os testes unitários configurados para o ambiente isolado.

  6. O servidor executa cada teste unitário no ambiente isolado:

  1. Se um teste falhar, o servidor captura a mensagem de erro.

  2. Se um teste exceder um tempo limite de execução (ex: 30 segundos), o servidor interrompe a execução e marca como "Timeout".

  3. O servidor limpa o ambiente isolado após a execução.

  4. O servidor armazena os resultados no banco de dados.

  5. O servidor inicia a geração do relatório de testes (RF05.3).

Resultado Esperado: Os testes são executados com segurança em um ambiente isolado e os resultados são registrados.

RF05.3 Gerar Relatórios de Testes

Após a execução, o sistema deve compilar um relatório detalhado indicando quais testes passaram e quais falharam, e a razão da falha.

Tela da visão do professor da atividade

Relatório gerado pelo sistema, disponível no Moodle

  1. Após a execução dos testes (RF05.2), o servidor gera um relatório.

  2. O relatório inclui:

  1. O relatório é armazenado no banco de dados e associado à submissão.

  2. O relatório é exibido ao aluno na interface web:

  1. O professor também pode visualizar o relatório:
  1. O relatório pode ser exportado em formato PDF ou CSV (funcionalidade opcional).

Resultado Esperado: Um relatório detalhado dos testes é gerado e disponibilizado ao aluno e ao professor.

RF05.4 Definir Casos de Testes

Permite ao Professor especificar os diferentes cenários de entrada e saída esperada para cada teste unitário.

  1. Durante a configuração de testes (RF05.1 ou RF03.7), o professor define casos de teste.

  2. Para cada teste, o professor pode definir múltiplos casos de teste:

  1. O professor pode adicionar quantos casos de teste desejar.

  2. O professor clica em "Salvar Casos de Teste".

  3. O sistema valida os casos de teste:

  1. Se houver erros, o sistema exibe mensagens de erro.

  2. Se forem válidos, o sistema armazena os casos de teste.

  3. Durante a execução dos testes (RF05.2), cada caso de teste é executado:

Resultado Esperado: Casos de teste são definidos e executados para validar o código do aluno.

RF05.5 Calcular Pontuação Automática

Com base no número de testes unitários que passaram, o sistema deve calcular automaticamente uma pontuação para a submissão do aluno.

  1. Após a execução de todos os testes (RF05.2), o servidor calcula a pontuação.

  2. O cálculo é realizado da seguinte forma:

  1. Exemplo:

  1. O servidor armazena a pontuação no banco de dados.

  2. O servidor atualiza o livro de notas do Moodle (se integrado) com a pontuação.

  3. O aluno visualiza sua pontuação:

  1. O professor visualiza as pontuações de todos os alunos:

Resultado Esperado: A pontuação do aluno é calculada automaticamente com base no desempenho nos testes.

7. DIAGRAMA DE ATIVIDADES E FLUXOGRAMAS

Fluxograma para envio das soluções

flowchart TD
  A[Aluno abre terminal] --> B[Digita comando<br>'edugit enviar atividade1']
    
  B --> C{Sistema verifica<br>autenticação}
  C -->|Não autenticado| D[Executa login<br>edugit login]
  C -->|Já autenticado| E[Valida estrutura<br>do código]
    
  D --> E
    
  E --> F{Validação aprovada?}
  F -->|Não| G[Exibe erro específico<br>Ex: “Função X não encontrada”]
  F -->|Sim| H[Compacta e envia<br>código para servidor]
    
  G --> B
    
  H --> I[Servidor recebe<br>e valida submissão]
  I --> J[Executa testes<br>unitários em container Docker]
    
  J --> K[Gera resultado<br>dos testes]
  K --> L[Exibe feedback<br>imediato no terminal]
    
  L --> M[Atualiza status<br>no Moodle]
  M --> N[🎉 Submissão<br>concluída com sucesso!]
    
  %% Estilização
  style A fill:#e1f5fe
  style B fill:#f3e5f5
  style L fill:#c8e6c9
  style N fill:#4caf50,color:white
  style G fill:#ffcdd2

Flucograma para escrever as soluções seguindo template do professor

flowchart TD
  A[Aluno: edugit baixar atividade1] --> B[Busca template do professor]
    
  B --> C[Download do código base<br>para pasta local]
  C --> D[Estrutura recebida:<br>atividade1.py<br>README.md<br>testes_unitarios.py]
    
  D --> E[Aluno abre editor<br>e analisa código]
  E --> F[Identifica funções<br>incompletas TODO]
    
  F --> G[Desenvolve solução<br>nas áreas marcadas]
    
  G --> H[Teste local opcional<br>edugit testar-local]
  H --> I{Testes passam<br>localmente?}
  I -->|Não| G
  I -->|Sim| J[Envio para correção<br>edugit enviar atividade1]
    
  J --> K[Validação automática<br>do formato]
  K --> L[Execução em container<br>Docker seguro]
  L --> M[Feedback imediato<br>com detalhes]
    
  M --> N{Submissão<br>bem-sucedida?}
  N -->|Não| O[Corrigir problemas<br>e reenviar]
  N -->|Sim| P[🎉 Código aceito!<br>Nota no Moodle]
    
  O --> G
    
  %% Estilos
  style A fill:#e1f5fe
  style C fill:#f3e5f5
  style G fill:#fff9c4
  style H fill:#ffecb3
  style P fill:#4caf50,color:white
  style O fill:#ffcdd2

Fluxograma do Professor

flowchart LR
    P[Professor] --> C[Cria template<br>com TODOs]
    C --> U[Upload para<br>sistema EduGit]
    U --> D[Disponibiliza para<br>download dos alunos]
    D --> S[Monitora submissões<br>em tempo real]
    S --> F[Feedback automático<br>para alunos]

Exemplificação do passo a passo do aluno pelo terminal

Download do template: edugit baixar calculadora_basica

Navega para pasta: cd calculadora_basica

Abre no editor (exemplo): code atividade1.py (Desenvolve a solução - aluno implementa as funções TODOs)

Testa localmente (opcional): edugit testar

Envia para correção: edugit enviar calculadora_basica